/**
 * Our Sweet Home 工具函数库
 * 版本: 1.0.0
 * 日期: 2025.9.24
 */

/**
 * 格式化时间
 * @param {Date} date 日期对象
 * @param {String} format 格式化模板，默认 'YYYY/MM/DD hh:mm:ss'
 * @return {String} 格式化后的时间字符串
 */
const formatTime = (date, format = 'YYYY/MM/DD hh:mm:ss') => {
  if (!date) return '';
  if (typeof date === 'string') {
    date = new Date(date.replace(/-/g, '/'));
  }
  if (typeof date === 'number') {
    date = new Date(date);
  }
  
  const year = date.getFullYear();
  const month = date.getMonth() + 1;
  const day = date.getDate();
  const hour = date.getHours();
  const minute = date.getMinutes();
  const second = date.getSeconds();
  
  const formatObj = {
    'YYYY': year,
    'MM': formatNumber(month),
    'DD': formatNumber(day),
    'hh': formatNumber(hour),
    'mm': formatNumber(minute),
    'ss': formatNumber(second)
  };
  
  return format.replace(/(YYYY|MM|DD|hh|mm|ss)/g, (match) => {
    return formatObj[match];
  });
};

/**
 * 格式化数字
 * @param {Number} n 数字
 * @return {String} 格式化后的字符串
 */
const formatNumber = n => {
  n = n.toString();
  return n[1] ? n : `0${n}`;
};

/**
 * 计算两个日期之间的天数差
 * @param {Date|String} date1 日期1
 * @param {Date|String} date2 日期2，默认为当前日期
 * @return {Number} 天数差
 */
const daysBetween = (date1, date2 = new Date()) => {
  if (typeof date1 === 'string') {
    date1 = new Date(date1.replace(/-/g, '/'));
  }
  if (typeof date2 === 'string') {
    date2 = new Date(date2.replace(/-/g, '/'));
  }
  
  // 转换为UTC时间戳，消除时区影响
  const time1 = Date.UTC(date1.getFullYear(), date1.getMonth(), date1.getDate());
  const time2 = Date.UTC(date2.getFullYear(), date2.getMonth(), date2.getDate());
  
  // 计算天数差
  return Math.floor((time2 - time1) / (1000 * 60 * 60 * 24));
};

/**
 * 格式化金额
 * @param {Number} amount 金额
 * @param {Number} decimals 小数位数，默认2位
 * @return {String} 格式化后的金额字符串
 */
const formatAmount = (amount, decimals = 2) => {
  if (isNaN(amount)) return '0.00';
  return parseFloat(amount).toFixed(decimals);
};

/**
 * 获取相对时间描述
 * @param {Date|String} date 日期
 * @return {String} 相对时间描述
 */
const getRelativeTime = (date) => {
  if (!date) return '';
  if (typeof date === 'string') {
    date = new Date(date.replace(/-/g, '/'));
  }
  
  const now = new Date();
  const diff = now.getTime() - date.getTime();
  
  // 小于1分钟
  if (diff < 60 * 1000) {
    return '刚刚';
  }
  
  // 小于1小时
  if (diff < 60 * 60 * 1000) {
    return Math.floor(diff / (60 * 1000)) + '分钟前';
  }
  
  // 小于24小时
  if (diff < 24 * 60 * 60 * 1000) {
    return Math.floor(diff / (60 * 60 * 1000)) + '小时前';
  }
  
  // 小于30天
  if (diff < 30 * 24 * 60 * 60 * 1000) {
    return Math.floor(diff / (24 * 60 * 60 * 1000)) + '天前';
  }
  
  // 大于30天，显示具体日期
  return formatTime(date, 'YYYY/MM/DD');
};

/**
 * 生成随机字符串
 * @param {Number} length 长度，默认6位
 * @return {String} 随机字符串
 */
const randomString = (length = 6) => {
  const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
  let result = '';
  for (let i = 0; i < length; i++) {
    result += chars.charAt(Math.floor(Math.random() * chars.length));
  }
  return result;
};

/**
 * 深拷贝对象
 * @param {Object} obj 要拷贝的对象
 * @return {Object} 拷贝后的对象
 */
const deepClone = (obj) => {
  if (obj === null || typeof obj !== 'object') return obj;
  
  // 处理日期对象
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  // 处理数组
  if (Array.isArray(obj)) {
    return obj.map(item => deepClone(item));
  }
  
  // 处理对象
  const cloneObj = {};
  for (const key in obj) {
    if (obj.hasOwnProperty(key)) {
      cloneObj[key] = deepClone(obj[key]);
    }
  }
  return cloneObj;
};

/**
 * 防抖函数
 * @param {Function} fn 要执行的函数
 * @param {Number} delay 延迟时间，默认300ms
 * @return {Function} 防抖后的函数
 */
const debounce = (fn, delay = 300) => {
  let timer = null;
  return function(...args) {
    if (timer) clearTimeout(timer);
    timer = setTimeout(() => {
      fn.apply(this, args);
    }, delay);
  };
};

/**
 * 节流函数
 * @param {Function} fn 要执行的函数
 * @param {Number} interval 间隔时间，默认300ms
 * @return {Function} 节流后的函数
 */
const throttle = (fn, interval = 300) => {
  let lastTime = 0;
  return function(...args) {
    const now = Date.now();
    if (now - lastTime >= interval) {
      lastTime = now;
      fn.apply(this, args);
    }
  };
};

/**
 * 检查对象是否为空
 * @param {Object} obj 要检查的对象
 * @return {Boolean} 是否为空
 */
const isEmpty = (obj) => {
  if (obj === null || obj === undefined) return true;
  if (typeof obj === 'string') return obj.trim() === '';
  if (Array.isArray(obj)) return obj.length === 0;
  if (typeof obj === 'object') return Object.keys(obj).length === 0;
  return false;
};

/**
 * 获取文件扩展名
 * @param {String} filename 文件名
 * @return {String} 扩展名
 */
const getFileExt = (filename) => {
  if (!filename) return '';
  return filename.substring(filename.lastIndexOf('.') + 1).toLowerCase();
};

/**
 * 导出所有工具函数
 */
module.exports = {
  formatTime,
  formatNumber,
  daysBetween,
  formatAmount,
  getRelativeTime,
  randomString,
  deepClone,
  debounce,
  throttle,
  isEmpty,
  getFileExt
};